/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package edu.cast.teseg.algoritmos.dinamico;

import edu.cast.teseg.modelo.RedSocial;
import edu.cast.teseg.modelo.Relaciones;
import java.util.Iterator;
import java.util.TreeMap;

/**
 *
 * @author edgarin
 */
public class Warshall {
    private TreeMap vertices;
    private TreeMap aristas;
    private int porcentajeSi;
    private int porcentajeNo;
    private int[] nodo_cumple;    
    private int[][] matrizAdj;
    private int[][] caminosCortos;
    
    public Warshall() {}
    
    //*** metodo para configurar las matrises con infinito ***//
    public void configurarWarhall(RedSocial grafo){
        aristas = new TreeMap();
        vertices = new TreeMap();
        aristas = grafo.getRelaciones();
        vertices = grafo.getIndividuos();
        
        matrizAdj = grafo.getMatrizAdj(); 
        nodo_cumple = new int[matrizAdj.length];
        caminosCortos = new int[matrizAdj.length][matrizAdj.length];
        
        
        for (int i = 0; i < matrizAdj.length; i++) {
            for (int j = 0; j < matrizAdj.length; j++) {
                if(matrizAdj[i][j]==0 && i!=j){
                    matrizAdj[i][j] = 999;
                }
                caminosCortos[i][j]=999;
            }
            nodo_cumple[i]=1;            
        }        
    }
    
    //*** metodo que encuentra todos los caminos minimos ***//
    public void iniciarWarshall(){
       
        int n = matrizAdj.length;       
        for (int k = 0; k < n; k++) {
             for (int i = 0; i < n; i++) {
                 for (int j = 0; j < n; j++) {
                     if(matrizAdj[i][j]>matrizAdj[i][k]+ matrizAdj[k][j]){
                         matrizAdj[i][j] = matrizAdj[i][k]+ matrizAdj[k][j];
                         caminosCortos[i][j] = i;
                     }
                 }
            }    
        }
        
         for (int v = 0; v < n; v++) {            
            for (int k = v+1; k < n; k++) {
               if(matrizAdj[v][k]>6 && matrizAdj[v][k]!=999){
                   nodo_cumple[v] = 0;
               }               
            }
        }         
         calcularPorcentaje();
    }
    
    // *** metodo Beta para implementar ingenuo ***//
    private int[] encontrarCaminos(int v, int k){
           /*
        
        for (int v = 0; v < vertices.size(); v++) {            
            for (int k = v+1; k < vertices.size(); k++) {
               int[] caminos = encontrarCaminos(v, k);
               int camino_min = minimo(caminos);
            }            
        }
        */
        
        
        int cantNodos=0;
        int[] resultado = null;
        
        
        for (Iterator it = aristas.values().iterator(); it.hasNext();) {
            Relaciones arista = (Relaciones)it.next();
            
            if(((arista.getOrigen()-1)==v) && (arista.getDestino()-1)==k){
                cantNodos++;   
                break;                
            }
            else  if(((arista.getOrigen()-1)==k) && (arista.getDestino()-1)==v){
                cantNodos++;
                break;
            }
            
            else if(v==(arista.getOrigen()-1)){
                for (Iterator it1 = aristas.values().iterator(); it1.hasNext();) {
                    Relaciones rel = (Relaciones) it1.next();
                  if((arista.getDestino()-1) == (rel.getOrigen()-1)){
                      cantNodos++;
                      if ((rel.getDestino()-1)==k) {
                          cantNodos++;
                          break;
                      }
                  }
                  else if((arista.getOrigen()-1) == (rel.getDestino()-1)){
                      cantNodos++;
                      if ((rel.getOrigen()-1)==k) {
                          cantNodos++;
                          break;
                      }
                  }
                  
               }
            }
        }
        
        resultado = new int[cantNodos];
        for (int i = 0; i < resultado.length; i++) {
            resultado[i] = cantNodos;
        }
        cantNodos=0;
        
        return resultado;        
    }
    
    //*** metodo que promedia la cantidad de vertices que cumplen la teoria ***//
    private void calcularPorcentaje(){
        porcentajeSi = 0;
        for (int v = 0; v < matrizAdj.length; v++) {
            porcentajeSi += nodo_cumple[v];
        }
        porcentajeNo = matrizAdj.length-porcentajeSi;
        porcentajeNo = (porcentajeNo*100)/matrizAdj.length;
        porcentajeSi = (porcentajeSi*100)/matrizAdj.length;
        
    }

    //*** metodo Beta para sacar el minimo ***//
    public int minimo(int[] caminos){
       int minimo = 0;
      /*  for (int i = 0; i<caminos.length; i++) {
            if(minimo>caminos[i]){
                minimo = caminos[i];
            }
        }        
       */ return minimo;
    }

    public int getPorcentajeSi() { return porcentajeSi; }

    public int getPorcentajeNo() { return porcentajeNo; }

    public void setPorcentajeNo(int porcentajeNo) {
        this.porcentajeNo = porcentajeNo;
    }

    public void setPorcentajeSi(int porcentajeSi) {
        this.porcentajeSi = porcentajeSi;
    }
    
}
